home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 2: CDPD 1 / Almathera Ten on Ten - Disc 2: CDPD 1.iso / pd / 651-660 / 658 / skew / source / skew3.c < prev   
C/C++ Source or Header  |  1995-03-15  |  47KB  |  1,556 lines
  1.  
  2. /*
  3.  *      skew3.c     --      stuff needed for writing output file
  4.  *
  5.  */
  6.  
  7.  
  8. #define DEBUG 1
  9.  
  10. #include <stdio.h>
  11. #include "skew.h"
  12.  
  13. /* flags related to gadgets & output file */
  14. extern long Flag1;
  15. extern long Flag2A;
  16. extern long Flag2B;
  17. extern long Flag3;
  18.  
  19. /* flags for cycle gadgets on display #2 (zero indexing) */
  20. extern int WaitingMode_FLAG, Variables_FLAG, Comments_FLAG, FillIns_FLAG,
  21.             WaitingMode_START, Variables_START, Comments_START, FillIns_START;
  22.  
  23. /* name for top-level function, as well as prefix & suffix for the rest */
  24. extern char *IDCMP_WIN_BUF, *TOP_LEVEL_BUF, *PREFIX_BUF, *SUFFIX_BUF;
  25.  
  26. extern char *IDCMP_WIN_NAME;
  27.  
  28. /*  function prototypes  */
  29. int GenerateCode( FILE *f );
  30. int WriteHeader( FILE *f );
  31. int WriteGlobalDefs( FILE *f );
  32. int WriteLocalDefs( FILE *f );
  33. int WriteProtos( FILE *f );
  34. int WriteTopLevelF( FILE *f );
  35. int WriteCases( FILE *f );
  36. int WriteFSkeletons( FILE *f );
  37. int WriteFillIn( FILE *f );
  38. int Pad( *f );
  39.  
  40.  
  41. int GenerateCode( FILE *f )
  42. {
  43.     if ( Comments_FLAG != NO_COMMENTS )
  44.         WriteHeader( f );
  45.  
  46.     /* in the current version this flag is always made global */
  47.     fputs( "BOOL IDCMP_DONE = FALSE;", f );
  48.     if ( Comments_FLAG == VERBOSE_COMMENTS ) {
  49.   fputs( "      /* you may try to make this flag local */\n", f );
  50.     }
  51.     else
  52.         fputs( "\n", f );
  53.  
  54.     if ( Variables_FLAG == GLOBAL )
  55.         WriteGlobalDefs( f );
  56.  
  57.     if ( Flag3 & Prototypes_FLAG )
  58.         WriteProtos( f );
  59.  
  60.     WriteTopLevelF( f );
  61.  
  62.     if ( Flag3 & Skeletons_FLAG )
  63.         WriteFSkeletons( f );
  64.  
  65.     if ( Comments_FLAG != NO_COMMENTS )
  66.   fputs( "\n    /* ------  end of Skew-generated file  ------ */\n", f );
  67. }
  68.  
  69.  
  70. int WriteHeader( FILE *f )
  71. {
  72.   fputs( "\n/*\n *    Code generated by SKEleton Writer V0.92\n *\n */\n\n", f );
  73. }
  74.  
  75.  
  76. int WriteGlobalDefs( FILE *f )
  77. {
  78.     fputs( "\n", f );
  79.  
  80.     if ( ( Flag1 & CLASS_FLAG ) | Flag2A | Flag2B )
  81.         fputs( "ULONG  Class;\n", f );
  82.  
  83.     if ( Flag1 & CODE_FLAG )
  84.         fputs( "USHORT Code;\n", f );
  85.  
  86.     if ( Flag1 & QUALIFIER_FLAG )
  87.         fputs( "USHORT Qualifier;\n", f );
  88.  
  89.     if ( Flag1 & IADDRESS_FLAG )
  90.         fputs( "APTR   IAddress;\n", f );
  91.  
  92.     if ( Flag1 & MOUSEX_FLAG )
  93.         fputs( "SHORT  MouseX;\n", f );
  94.  
  95.     if ( Flag1 & MOUSEY_FLAG )
  96.         fputs( "SHORT  MouseY;\n", f );
  97.  
  98.     if ( Flag1 & SECONDS_FLAG )
  99.         fputs( "ULONG  Seconds;\n", f );
  100.  
  101.     if ( Flag1 & MICROS_FLAG )
  102.         fputs( "ULONG  Micros;\n", f );
  103. }
  104.  
  105.  
  106. int WriteLocalDefs( FILE *f )
  107. {
  108.     fputs( "\n", f );
  109.  
  110.     if ( ( Flag1 & CLASS_FLAG ) | Flag2A | Flag2B  )
  111.         fputs( "    ULONG  class;\n", f );
  112.  
  113.     if ( Flag1 & CODE_FLAG )
  114.         fputs( "    USHORT code;\n", f );
  115.  
  116.     if ( Flag1 & QUALIFIER_FLAG )
  117.         fputs( "    USHORT qualifier;\n", f );
  118.  
  119.     if ( Flag1 & IADDRESS_FLAG )
  120.         fputs( "    APTR   iaddress;\n", f );
  121.  
  122.     if ( Flag1 & MOUSEX_FLAG )
  123.         fputs( "    SHORT  mouse_x;\n", f );
  124.  
  125.     if ( Flag1 & MOUSEY_FLAG )
  126.         fputs( "    SHORT  mouse_y;\n", f );
  127.  
  128.     if ( Flag1 & SECONDS_FLAG )
  129.         fputs( "    ULONG  seconds;\n", f );
  130.  
  131.     if ( Flag1 & MICROS_FLAG )
  132.         fputs( "    ULONG  micros;\n", f );
  133. }
  134.  
  135.  
  136. int WriteProtos( FILE *f )
  137. {
  138.     fputs( "\n", f );
  139.  
  140.     fprintf( f, "void %s( void );\n\n", TOP_LEVEL_BUF );
  141.  
  142.     if ( Flag2A & MOUSEBUTTONS_F_FLAG ) {
  143.         if ( Variables_FLAG == LOCAL ) {
  144.             WriteFillIn( f );
  145.             Pad( f );
  146.             fprintf( f, "%sMouseButtons%s(", PREFIX_BUF, SUFFIX_BUF );
  147.             Pad( f );
  148.             WriteFillIn( f );
  149.             Pad( f );
  150.             fputs( ");\n", f );
  151.         }
  152.         else {
  153.    fprintf( f, "void %sMouseButtons%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  154.         }
  155.     }
  156.     if ( Flag2A & MOUSEMOVE_F_FLAG ) {
  157.         if ( Variables_FLAG == LOCAL ) {
  158.             WriteFillIn( f );
  159.             Pad( f );;
  160.             fprintf( f, "%sMouseMove%s(", PREFIX_BUF, SUFFIX_BUF  );
  161.             Pad( f );;
  162.             WriteFillIn( f );
  163.             Pad( f );
  164.             fputs( ");\n", f );
  165.         }
  166.         else {
  167.    fprintf( f, "void %sMouseMove%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  168.         }
  169.     }
  170.     if ( Flag2A & DELTAMOVE_F_FLAG ) {
  171.         if ( Variables_FLAG == LOCAL ) {
  172.             WriteFillIn( f );
  173.             Pad( f );
  174.             fprintf( f, "%sDeltaMove%s(", PREFIX_BUF, SUFFIX_BUF  );
  175.             Pad( f );
  176.             WriteFillIn( f );
  177.             Pad( f );
  178.             fputs( ");\n", f );
  179.         }
  180.         else {
  181.    fprintf( f, "void %sDeltaMove%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  182.         }
  183.     }
  184.     if ( Flag2A & GADGETDOWN_F_FLAG ) {
  185.         if ( Variables_FLAG == LOCAL ) {
  186.             WriteFillIn( f );
  187.             Pad( f );
  188.             fprintf( f, "%sGadgetDown%s(", PREFIX_BUF, SUFFIX_BUF  );
  189.             Pad( f );
  190.             WriteFillIn( f );
  191.             Pad( f );
  192.             fputs( ");\n", f );
  193.         }
  194.         else {
  195.    fprintf( f, "void %sGadgetDown%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  196.         }
  197.     }
  198.     if ( Flag2A & GADGETUP_F_FLAG ) {
  199.         if ( Variables_FLAG == LOCAL ) {
  200.             WriteFillIn( f );
  201.             Pad( f );
  202.             fprintf( f, "%sGadgetUp%s(", PREFIX_BUF, SUFFIX_BUF  );
  203.             Pad( f );
  204.             WriteFillIn( f );
  205.             Pad( f );
  206.             fputs( ");\n", f );
  207.         }
  208.         else {
  209.    fprintf( f, "void %sGadgetUp%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  210.         }
  211.     }
  212.     if ( Flag2A & CLOSEWINDOW_F_FLAG ) {
  213.         if ( Variables_FLAG == LOCAL ) {
  214.             WriteFillIn( f );
  215.             Pad( f );
  216.             fprintf( f, "%sCloseWindow%s(", PREFIX_BUF, SUFFIX_BUF  );
  217.             Pad( f );
  218.             WriteFillIn( f );
  219.             Pad( f );
  220.             fputs( ");\n", f );
  221.         }
  222.         else {
  223.    fprintf( f, "void %sCloseWindow%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  224.         }
  225.     }
  226.     if ( Flag2A & MENUPICK_F_FLAG ) {
  227.         if ( Variables_FLAG == LOCAL ) {
  228.             WriteFillIn( f );
  229.             Pad( f );
  230.             fprintf( f, "%sMenuPick%s(", PREFIX_BUF, SUFFIX_BUF  );
  231.             Pad( f );
  232.             WriteFillIn( f );
  233.             Pad( f );
  234.             fputs( ");\n", f );
  235.         }
  236.         else {
  237.    fprintf( f, "void %sMenuPick%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  238.         }
  239.     }
  240.     if ( Flag2A & MENUVERIFY_F_FLAG ) {
  241.         if ( Variables_FLAG == LOCAL ) {
  242.             WriteFillIn( f );
  243.             Pad( f );
  244.             fprintf( f, "%sMenuVerify%s(", PREFIX_BUF, SUFFIX_BUF  );
  245.             Pad( f );
  246.             WriteFillIn( f );
  247.             Pad( f );
  248.             fputs( ");\n", f );
  249.         }
  250.         else {
  251.    fprintf( f, "void %sMenuVerify%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  252.         }
  253.     }
  254.     if ( Flag2A & MENUHELP_F_FLAG ) {
  255.         if ( Variables_FLAG == LOCAL ) {
  256.             WriteFillIn( f );
  257.             Pad( f );
  258.             fprintf( f, "%sMenuHelp%s(", PREFIX_BUF, SUFFIX_BUF  );
  259.             Pad( f );
  260.             WriteFillIn( f );
  261.             Pad( f );
  262.             fputs( ");\n", f );
  263.         }
  264.         else {
  265.    fprintf( f, "void %sMenuHelp%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  266.         }
  267.     }
  268.     if ( Flag2A & RAWKEY_F_FLAG ) {
  269.         if ( Variables_FLAG == LOCAL ) {
  270.             WriteFillIn( f );
  271.             Pad( f );
  272.             fprintf( f, "%sRawKey%s(", PREFIX_BUF, SUFFIX_BUF  );
  273.             Pad( f );
  274.             WriteFillIn( f );
  275.             Pad( f );
  276.             fputs( ");\n", f );
  277.         }
  278.         else {
  279.    fprintf( f, "void %sRawKey%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  280.         }
  281.     }
  282.     if ( Flag2A & VANILLAKEY_F_FLAG ) {
  283.         if ( Variables_FLAG == LOCAL ) {
  284.             WriteFillIn( f );
  285.             Pad( f );
  286.             fprintf( f, "%sVanillaKey%s(", PREFIX_BUF, SUFFIX_BUF  );
  287.             Pad( f );
  288.             WriteFillIn( f );
  289.             Pad( f );
  290.             fputs( ");\n", f );
  291.         }
  292.         else {
  293.    fprintf( f, "void %sVanillaKey%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  294.         }
  295.     }
  296.     if ( Flag2A & REQSET_F_FLAG ) {
  297.         if ( Variables_FLAG == LOCAL ) {
  298.             WriteFillIn( f );
  299.             Pad( f );
  300.             fprintf( f, "%sReqSet%s(", PREFIX_BUF, SUFFIX_BUF  );
  301.             Pad( f );
  302.             WriteFillIn( f );
  303.             Pad( f );
  304.             fputs( ");\n", f );
  305.         }
  306.         else {
  307.    fprintf( f, "void %sReqSet%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  308.         }
  309.     }
  310.     if ( Flag2A & REQCLEAR_F_FLAG ) {
  311.         if ( Variables_FLAG == LOCAL ) {
  312.             WriteFillIn( f );
  313.             Pad( f );
  314.             fprintf( f, "%sReqClear%s(", PREFIX_BUF, SUFFIX_BUF  );
  315.             Pad( f );
  316.             WriteFillIn( f );
  317.             Pad( f );
  318.             fputs( ");\n", f );
  319.         }
  320.         else {
  321.    fprintf( f, "void %sReqClear%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  322.         }
  323.     }
  324.     if ( Flag2A & REQVERIFY_F_FLAG ) {
  325.         if ( Variables_FLAG == LOCAL ) {
  326.             WriteFillIn( f );
  327.             Pad( f );
  328.             fprintf( f, "%sReqVerify%s(", PREFIX_BUF, SUFFIX_BUF  );
  329.             Pad( f );
  330.             WriteFillIn( f );
  331.             Pad( f );
  332.             fputs( ");\n", f );
  333.         }
  334.         else {
  335.    fprintf( f, "void %sReqVerify%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  336.         }
  337.     }
  338.     if ( Flag2B & NEWSIZE_F_FLAG ) {
  339.         if ( Variables_FLAG == LOCAL ) {
  340.             WriteFillIn( f );
  341.             Pad( f );
  342.             fprintf( f, "%sNewSize%s(", PREFIX_BUF, SUFFIX_BUF  );
  343.             Pad( f );
  344.             WriteFillIn( f );
  345.             Pad( f );
  346.             fputs( ");\n", f );
  347.         }
  348.         else {
  349.    fprintf( f, "void %sNewSize%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  350.         }
  351.     }
  352.     if ( Flag2B & SIZEVERIFY_F_FLAG ) {
  353.         if ( Variables_FLAG == LOCAL ) {
  354.             WriteFillIn( f );
  355.             Pad( f );
  356.             fprintf( f, "%sSizeVerify%s(", PREFIX_BUF, SUFFIX_BUF  );
  357.             Pad( f );
  358.             WriteFillIn( f );
  359.             Pad( f );
  360.             fputs( ");\n", f );
  361.         }
  362.         else {
  363.    fprintf( f, "void %sSizeVerify%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  364.         }
  365.     }
  366.     if ( Flag2B & ACTIVEWINDOW_F_FLAG ) {
  367.         if ( Variables_FLAG == LOCAL ) {
  368.             WriteFillIn( f );
  369.             Pad( f );
  370.             fprintf( f, "%sActiveWindow%s(", PREFIX_BUF, SUFFIX_BUF  );
  371.             Pad( f );
  372.             WriteFillIn( f );
  373.             Pad( f );
  374.             fputs( ");\n", f );
  375.         }
  376.         else {
  377.    fprintf( f, "void %sActiveWindow%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  378.         }
  379.     }
  380.     if ( Flag2B & INACTIVEWINDOW_F_FLAG ) {
  381.         if ( Variables_FLAG == LOCAL ) {
  382.             WriteFillIn( f );
  383.             Pad( f );
  384.             fprintf( f, "%sInactiveWindow%s(", PREFIX_BUF, SUFFIX_BUF  );
  385.             Pad( f );
  386.             WriteFillIn( f );
  387.             Pad( f );
  388.             fputs( ");\n", f );
  389.         }
  390.         else {
  391.    fprintf( f, "void %sInactiveWindow%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  392.         }
  393.     }
  394.     if ( Flag2B & CHANGEWINDOW_F_FLAG ) {
  395.         if ( Variables_FLAG == LOCAL ) {
  396.             WriteFillIn( f );
  397.             Pad( f );
  398.             fprintf( f, "%sChangeWindow%s(", PREFIX_BUF, SUFFIX_BUF  );
  399.             Pad( f );
  400.             WriteFillIn( f );
  401.             Pad( f );
  402.             fputs( ");\n", f );
  403.         }
  404.         else {
  405.    fprintf( f, "void %sChangeWindow%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  406.         }
  407.     }
  408.     if ( Flag2B & REFRESHWINDOW_F_FLAG ) {
  409.         if ( Variables_FLAG == LOCAL ) {
  410.             WriteFillIn( f );
  411.             Pad( f );
  412.             fprintf( f, "%sRefreshWindow%s(", PREFIX_BUF, SUFFIX_BUF  );
  413.             Pad( f );
  414.             WriteFillIn( f );
  415.             Pad( f );
  416.             fputs( ");\n", f );
  417.         }
  418.         else {
  419.    fprintf( f, "void %sRefreshWindow%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  420.         }
  421.     }
  422.     if ( Flag2B & DISKINSERTED_F_FLAG ) {
  423.         if ( Variables_FLAG == LOCAL ) {
  424.             WriteFillIn( f );
  425.             Pad( f );
  426.             fprintf( f, "%sDiskInserted%s(", PREFIX_BUF, SUFFIX_BUF  );
  427.             Pad( f );
  428.             WriteFillIn( f );
  429.             Pad( f );
  430.             fputs( ");\n", f );
  431.         }
  432.         else {
  433.    fprintf( f, "void %sDiskInserted%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  434.         }
  435.     }
  436.     if ( Flag2B & DISKREMOVED_F_FLAG ) {
  437.         if ( Variables_FLAG == LOCAL ) {
  438.             WriteFillIn( f );
  439.             Pad( f );
  440.             fprintf( f, "%sDiskRemoved%s(", PREFIX_BUF, SUFFIX_BUF  );
  441.             Pad( f );
  442.             WriteFillIn( f );
  443.             Pad( f );
  444.             fputs( ");\n", f );
  445.         }
  446.         else {
  447.    fprintf( f, "void %sDiskRemoved%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  448.         }
  449.     }
  450.     if ( Flag2B & NEWPREFS_F_FLAG ) {
  451.         if ( Variables_FLAG == LOCAL ) {
  452.             WriteFillIn( f );
  453.             Pad( f );
  454.             fprintf( f, "%sNewPrefs%s(", PREFIX_BUF, SUFFIX_BUF  );
  455.             Pad( f );
  456.             WriteFillIn( f );
  457.             Pad( f );
  458.             fputs( ");\n", f );
  459.         }
  460.         else {
  461.    fprintf( f, "void %sNewPrefs%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  462.         }
  463.     }
  464.     if ( Flag2B & INTUITICKS_F_FLAG ) {
  465.         if ( Variables_FLAG == LOCAL ) {
  466.             WriteFillIn( f );
  467.             Pad( f );
  468.             fprintf( f, "%sIntuiTicks%s(", PREFIX_BUF, SUFFIX_BUF  );
  469.             Pad( f );
  470.             WriteFillIn( f );
  471.             Pad( f );
  472.             fputs( ");\n", f );
  473.         }
  474.         else {
  475.    fprintf( f, "void %sIntuiTicks%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  476.         }
  477.     }
  478.     if ( Flag2B & IDCMPUPDATE_F_FLAG ) {
  479.         if ( Variables_FLAG == LOCAL ) {
  480.             WriteFillIn( f );
  481.             Pad( f );
  482.             fprintf( f, "%sIDCMPUpdate%s(", PREFIX_BUF, SUFFIX_BUF  );
  483.             Pad( f );
  484.             WriteFillIn( f );
  485.             Pad( f );
  486.             fputs( ");\n", f );
  487.         }
  488.         else {
  489.    fprintf( f, "void %sIDCMPUpdate%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  490.         }
  491.     }
  492.     if ( Flag2B & LONELYMESSAGE_F_FLAG ) {
  493.         if ( Variables_FLAG == LOCAL ) {
  494.             WriteFillIn( f );
  495.             Pad( f );
  496.             fprintf( f, "%sLonelyMessage%s(", PREFIX_BUF, SUFFIX_BUF  );
  497.             Pad( f );
  498.             WriteFillIn( f );
  499.             Pad( f );
  500.             fputs( ");\n", f );
  501.         }
  502.         else {
  503.    fprintf( f, "void %sLonelyMessage%s( void );\n", PREFIX_BUF, SUFFIX_BUF );
  504.         }
  505.     }
  506. }
  507.  
  508.  
  509. WriteTopLevelF( FILE *f )
  510. {
  511.     fprintf( f, "\n\nvoid %s()\n{", TOP_LEVEL_BUF );
  512.  
  513.     fputs( "\n    struct IntuiMessage *im;\n", f );
  514.  
  515.     if ( Variables_FLAG == LOCAL )
  516.         WriteLocalDefs( f );
  517.  
  518.     fputs( "\n", f );
  519.  
  520.     fputs( "    while ( !IDCMP_DONE ) {\n", f );
  521.  
  522.     if ( WaitingMode_FLAG == PASSIVE ) {
  523.   fprintf( f, "        WaitPort( %s->UserPort );\n", IDCMP_WIN_BUF );
  524.     }
  525.     else {
  526.         fputs( "\n        ", f );
  527.         WriteFillIn( f );
  528.  
  529.         if ( Comments_FLAG == VERBOSE_COMMENTS ) {
  530.   fputs( "  /* do your thing while you're looping */\n\n", f );
  531.         }
  532.         else {
  533.             fputs( "\n\n", f );
  534.         }
  535.     }
  536.  
  537.     if ( Flag3 & gadtools_FLAG ) {
  538.   fprintf( f, "        while ( im = GT_GetIMsg( %s->UserPort ) ) {\n", IDCMP_WIN_BUF );
  539.     }
  540.     else {
  541.   fprintf( f, "        while ( im = GetMsg( %s->UserPort ) ) {\n", IDCMP_WIN_BUF );
  542.     }
  543.  
  544.     fputs( "\n", f );
  545.  
  546.     /* assignements */
  547.     if ( ( Flag1 & CLASS_FLAG ) | Flag2A | Flag2B ) {
  548.         if ( Variables_FLAG == LOCAL )
  549.             fputs( "            class     =  im->Class;\n", f );
  550.         else
  551.             fputs( "            Class     =  im->Class;\n", f );
  552.     }
  553.  
  554.     if ( Flag1 & CODE_FLAG ) {
  555.         if ( Variables_FLAG == LOCAL )
  556.             fputs( "            code      =  im->Code;\n", f );
  557.         else
  558.             fputs( "            Code      =  im->Code;\n", f );
  559.     }
  560.  
  561.     if ( Flag1 & QUALIFIER_FLAG ) {
  562.         if ( Variables_FLAG == LOCAL )
  563.             fputs( "            qualifier =  im->Qualifier;\n", f );
  564.         else
  565.             fputs( "            Qualifier =  im->Qualifier;\n", f );
  566.     }
  567.  
  568.     if ( Flag1 & IADDRESS_FLAG ) {
  569.         if ( Variables_FLAG == LOCAL )
  570.             fputs( "            iaddress  =  im->IAddress;\n", f );
  571.         else
  572.             fputs( "            IAddress  =  im->IAddress;\n", f );
  573.     }
  574.  
  575.     if ( Flag1 & MOUSEX_FLAG ) {
  576.         if ( Variables_FLAG == LOCAL )
  577.             fputs( "            mouse_x   =  im->MouseX;\n", f );
  578.         else
  579.             fputs( "            MouseX    =  im->MouseX;\n", f );
  580.     }
  581.  
  582.     if ( Flag1 & MOUSEY_FLAG ) {
  583.         if ( Variables_FLAG == LOCAL )
  584.             fputs( "            mouse_y   =  im->MouseY;\n", f );
  585.         else
  586.             fputs( "            MouseY    =  im->MouseY;\n", f );
  587.     }
  588.  
  589.     if ( Flag1 & SECONDS_FLAG ) {
  590.         if ( Variables_FLAG == LOCAL )
  591.             fputs( "            seconds   =  im->Seconds;\n", f );
  592.         else
  593.             fputs( "            Seconds   =  im->Seconds;\n", f );
  594.     }
  595.  
  596.     if ( Flag1 & MICROS_FLAG ) {
  597.         if ( Variables_FLAG == LOCAL )
  598.             fputs( "            micros    =  im->Micros;\n", f );
  599.         else
  600.             fputs( "            Micros    =  im->Micros;\n", f );
  601.     }
  602.  
  603.     fputs( "\n", f );
  604.  
  605.     /* we are replying the message... */
  606.     if ( Flag3 & gadtools_FLAG ) {
  607.         fprintf( f, "            GT_ReplyIMsg( im );\n", IDCMP_WIN_BUF );
  608.     }
  609.     else {
  610.         fprintf( f, "            ReplyMsg( im );\n", IDCMP_WIN_BUF );
  611.     }
  612.  
  613.     /* switch */
  614.     if ( Variables_FLAG == LOCAL ) {
  615.         fputs( "\n            switch ( class ) {\n", f );
  616.     }
  617.     else {
  618.         fputs( "\n            switch ( Class ) {\n", f );
  619.     }
  620.  
  621.     if ( !Flag2A && !Flag2B )
  622.         fputs( "\n\n", f );
  623.     else
  624.         WriteCases( f );
  625.  
  626.     fputs( "                default:\n", f );
  627.     fputs( "                    ", f );
  628.     WriteFillIn( f );
  629.     fputs( "\n                    break;\n", f );
  630.     fputs( "            }\n        }\n    }\n", f );
  631.  
  632.     fputs( "}\n", f );
  633.  
  634. }
  635.  
  636.  
  637. int WriteCases( FILE *f )
  638. {
  639.     if ( Flag2A & MOUSEBUTTONS_FLAG || Flag2A & MOUSEBUTTONS_F_FLAG ) {
  640.         fputs( "                case IDCMP_MOUSEBUTTONS:\n", f );
  641.         if ( Flag2A & MOUSEBUTTONS_F_FLAG ) {
  642.   fprintf( f, "                    %sMouseButtons%s(", PREFIX_BUF, SUFFIX_BUF );
  643.             Pad( f );
  644.             if ( Variables_FLAG == LOCAL )
  645.                 WriteFillIn( f );
  646.             Pad( f );
  647.             fputs( ");\n", f );
  648.         }
  649.         else {
  650.             fputs( "                    ", f );
  651.             WriteFillIn( f );
  652.             fputs( "\n", f );
  653.         }
  654.         fputs( "                    break;\n", f );
  655.     }
  656.  
  657.     if ( Flag2A & MOUSEMOVE_FLAG || Flag2A & MOUSEMOVE_F_FLAG ) {
  658.         fputs( "                case IDCMP_MOUSEMOVE:\n", f );
  659.         if ( Flag2A & MOUSEMOVE_F_FLAG ) {
  660.   fprintf( f, "                    %sMouseMove%s(", PREFIX_BUF, SUFFIX_BUF );
  661.             Pad( f );
  662.             if ( Variables_FLAG == LOCAL )
  663.                 WriteFillIn( f );
  664.             Pad( f );
  665.             fputs( ");\n", f );
  666.         }
  667.         else {
  668.             fputs( "                    ", f );
  669.             WriteFillIn( f );
  670.             fputs( "\n", f );
  671.         }
  672.         fputs( "                    break;\n", f );
  673.     }
  674.  
  675.     if ( Flag2A & DELTAMOVE_FLAG || Flag2A & DELTAMOVE_F_FLAG ) {
  676.         fputs( "                case IDCMP_DELTAMOVE:\n", f );
  677.         if ( Flag2A & DELTAMOVE_F_FLAG ) {
  678.   fprintf( f, "                    %sDeltaMove%s(", PREFIX_BUF, SUFFIX_BUF );
  679.             Pad( f );
  680.             if ( Variables_FLAG == LOCAL )
  681.                 WriteFillIn( f );
  682.             Pad( f );
  683.             fputs( ");\n", f );
  684.         }
  685.         else {
  686.             fputs( "                    ", f );
  687.             WriteFillIn( f );
  688.             fputs( "\n", f );
  689.         }
  690.         fputs( "                    break;\n", f );
  691.     }
  692.  
  693.     if ( Flag2A & GADGETDOWN_FLAG || Flag2A & GADGETDOWN_F_FLAG ) {
  694.         fputs( "                case IDCMP_GADGETDOWN:\n", f );
  695.         if ( Flag2A & GADGETDOWN_F_FLAG ) {
  696.   fprintf( f, "                    %sGadgetDown%s(", PREFIX_BUF, SUFFIX_BUF );
  697.             Pad( f );
  698.             if ( Variables_FLAG == LOCAL )
  699.                 WriteFillIn( f );
  700.             Pad( f );
  701.             fputs( ");\n", f );
  702.         }
  703.         else {
  704.             fputs( "                    ", f );
  705.             WriteFillIn( f );
  706.             fputs( "\n", f );
  707.         }
  708.         fputs( "                    break;\n", f );
  709.     }
  710.  
  711.     if ( Flag2A & GADGETUP_FLAG || Flag2A & GADGETUP_F_FLAG ) {
  712.         fputs( "                case IDCMP_GADGETUP:\n", f );
  713.         if ( Flag2A & GADGETUP_F_FLAG ) {
  714.   fprintf( f, "                    %sGadgetUp%s(", PREFIX_BUF, SUFFIX_BUF );
  715.             Pad( f );
  716.             if ( Variables_FLAG == LOCAL )
  717.                 WriteFillIn( f );
  718.             Pad( f );
  719.             fputs( ");\n", f );
  720.         }
  721.         else {
  722.             fputs( "                    ", f );
  723.             WriteFillIn( f );
  724.             fputs( "\n", f );
  725.         }
  726.         fputs( "                    break;\n", f );
  727.     }
  728.  
  729.     if ( Flag2A & CLOSEWINDOW_FLAG || Flag2A & CLOSEWINDOW_F_FLAG ) {
  730.         fputs( "                case IDCMP_CLOSEWINDOW:\n", f );
  731.         if ( Flag2A & CLOSEWINDOW_F_FLAG ) {
  732.   fprintf( f, "                    %sCloseWindow%s(", PREFIX_BUF, SUFFIX_BUF );
  733.             Pad( f );
  734.             if ( Variables_FLAG == LOCAL )
  735.                 WriteFillIn( f );
  736.             Pad( f );
  737.             fputs( ");\n", f );
  738.         }
  739.         else {
  740.             fputs( "                    ", f );
  741.             WriteFillIn( f );
  742.             fputs( "\n", f );
  743.         }
  744.         fputs( "                    break;\n", f );
  745.     }
  746.  
  747.     if ( Flag2A & MENUPICK_FLAG || Flag2A & MENUPICK_F_FLAG ) {
  748.         fputs( "                case IDCMP_MENUPICK:\n", f );
  749.         if ( Flag2A & MENUPICK_F_FLAG ) {
  750.   fprintf( f, "                    %sMenuPick%s(", PREFIX_BUF, SUFFIX_BUF );
  751.             Pad( f );
  752.             if ( Variables_FLAG == LOCAL )
  753.                 WriteFillIn( f );
  754.             Pad( f );
  755.             fputs( ");\n", f );
  756.         }
  757.         else {
  758.             fputs( "                    ", f );
  759.             WriteFillIn( f );
  760.             fputs( "\n", f );
  761.         }
  762.         fputs( "                    break;\n", f );
  763.     }
  764.  
  765.     if ( Flag2A & MENUVERIFY_FLAG || Flag2A & MENUVERIFY_F_FLAG ) {
  766.         fputs( "                case IDCMP_MENUVERIFY:\n", f );
  767.         if ( Flag2A & MENUVERIFY_F_FLAG ) {
  768.   fprintf( f, "                    %sMenuVerify%s(", PREFIX_BUF, SUFFIX_BUF );
  769.             Pad( f );
  770.             if ( Variables_FLAG == LOCAL )
  771.                 WriteFillIn( f );
  772.             Pad( f );
  773.             fputs( ");\n", f );
  774.         }
  775.         else {
  776.             fputs( "                    ", f );
  777.             WriteFillIn( f );
  778.             fputs( "\n", f );
  779.         }
  780.         fputs( "                    break;\n", f );
  781.     }
  782.  
  783.     if ( Flag2A & MENUHELP_FLAG || Flag2A & MENUHELP_F_FLAG ) {
  784.         fputs( "                case IDCMP_MENUHELP:\n", f );
  785.         if ( Flag2A & MENUHELP_F_FLAG ) {
  786.   fprintf( f, "                    %sMenuHelp%s(", PREFIX_BUF, SUFFIX_BUF );
  787.             Pad( f );
  788.             if ( Variables_FLAG == LOCAL )
  789.                 WriteFillIn( f );
  790.             Pad( f );
  791.             fputs( ");\n", f );
  792.         }
  793.         else {
  794.             fputs( "                    ", f );
  795.             WriteFillIn( f );
  796.             fputs( "\n", f );
  797.         }
  798.         fputs( "                    break;\n", f );
  799.     }
  800.  
  801.     if ( Flag2A & RAWKEY_FLAG || Flag2A & RAWKEY_F_FLAG ) {
  802.         fputs( "                case IDCMP_RAWKEY:\n", f );
  803.         if ( Flag2A & RAWKEY_F_FLAG ) {
  804.   fprintf( f, "                    %sRawKey%s(", PREFIX_BUF, SUFFIX_BUF );
  805.             Pad( f );
  806.             if ( Variables_FLAG == LOCAL )
  807.                 WriteFillIn( f );
  808.             Pad( f );
  809.             fputs( ");\n", f );
  810.         }
  811.         else {
  812.             fputs( "                    ", f );
  813.             WriteFillIn( f );
  814.             fputs( "\n", f );
  815.         }
  816.         fputs( "                    break;\n", f );
  817.     }
  818.  
  819.     if ( Flag2A & VANILLAKEY_FLAG || Flag2A & VANILLAKEY_F_FLAG ) {
  820.         fputs( "                case IDCMP_VANILLAKEY:\n", f );
  821.         if ( Flag2A & VANILLAKEY_F_FLAG ) {
  822.   fprintf( f, "                    %sVanillaKey%s(", PREFIX_BUF, SUFFIX_BUF );
  823.             Pad( f );
  824.             if ( Variables_FLAG == LOCAL )
  825.                 WriteFillIn( f );
  826.             Pad( f );
  827.             fputs( ");\n", f );
  828.         }
  829.         else {
  830.             fputs( "                    ", f );
  831.             WriteFillIn( f );
  832.             fputs( "\n", f );
  833.         }
  834.         fputs( "                    break;\n", f );
  835.     }
  836.  
  837.     if ( Flag2A & REQSET_FLAG || Flag2A & REQSET_F_FLAG ) {
  838.         fputs( "                case IDCMP_REQSET:\n", f );
  839.         if ( Flag2A & REQSET_F_FLAG ) {
  840.   fprintf( f, "                    %sReqSet%s(", PREFIX_BUF, SUFFIX_BUF );
  841.             Pad( f );
  842.             if ( Variables_FLAG == LOCAL )
  843.                 WriteFillIn( f );
  844.             Pad( f );
  845.             fputs( ");\n", f );
  846.         }
  847.         else {
  848.             fputs( "                    ", f );
  849.             WriteFillIn( f );
  850.             fputs( "\n", f );
  851.         }
  852.         fputs( "                    break;\n", f );
  853.     }
  854.  
  855.     if ( Flag2A & REQCLEAR_FLAG || Flag2A & REQCLEAR_F_FLAG ) {
  856.         fputs( "                case IDCMP_REQCLEAR:\n", f );
  857.         if ( Flag2A & REQCLEAR_F_FLAG ) {
  858.   fprintf( f, "                    %sReqClear%s(", PREFIX_BUF, SUFFIX_BUF );
  859.             Pad( f );
  860.             if ( Variables_FLAG == LOCAL )
  861.                 WriteFillIn( f );
  862.             Pad( f );
  863.             fputs( ");\n", f );
  864.         }
  865.         else {
  866.             fputs( "                    ", f );
  867.             WriteFillIn( f );
  868.             fputs( "\n", f );
  869.         }
  870.         fputs( "                    break;\n", f );
  871.     }
  872.  
  873.     if ( Flag2A & REQVERIFY_FLAG || Flag2A & REQVERIFY_F_FLAG ) {
  874.         fputs( "                case IDCMP_REQVERIFY:\n", f );
  875.         if ( Flag2A & REQVERIFY_F_FLAG ) {
  876.   fprintf( f, "                    %sReqVerify%s(", PREFIX_BUF, SUFFIX_BUF );
  877.             Pad( f );
  878.             if ( Variables_FLAG == LOCAL )
  879.                 WriteFillIn( f );
  880.             Pad( f );
  881.             fputs( ");\n", f );
  882.         }
  883.         else {
  884.             fputs( "                    ", f );
  885.             WriteFillIn( f );
  886.             fputs( "\n", f );
  887.         }
  888.         fputs( "                    break;\n", f );
  889.     }
  890.  
  891.     if ( Flag2B & NEWSIZE_FLAG || Flag2B & NEWSIZE_F_FLAG ) {
  892.         fputs( "                case IDCMP_NEWSIZE:\n", f );
  893.         if ( Flag2B & NEWSIZE_F_FLAG ) {
  894.   fprintf( f, "                    %sNewSize%s(", PREFIX_BUF, SUFFIX_BUF );
  895.             Pad( f );
  896.             if ( Variables_FLAG == LOCAL )
  897.                 WriteFillIn( f );
  898.             Pad( f );
  899.             fputs( ");\n", f );
  900.         }
  901.         else {
  902.             fputs( "                    ", f );
  903.             WriteFillIn( f );
  904.             fputs( "\n", f );
  905.         }
  906.         fputs( "                    break;\n", f );
  907.     }
  908.  
  909.     if ( Flag2B & SIZEVERIFY_FLAG || Flag2B & SIZEVERIFY_F_FLAG ) {
  910.         fputs( "                case IDCMP_SIZEVERIFY:\n", f );
  911.         if ( Flag2B & SIZEVERIFY_F_FLAG ) {
  912.   fprintf( f, "                    %sSizeVerify%s(", PREFIX_BUF, SUFFIX_BUF );
  913.             Pad( f );
  914.             if ( Variables_FLAG == LOCAL )
  915.                 WriteFillIn( f );
  916.             Pad( f );
  917.             fputs( ");\n", f );
  918.         }
  919.         else {
  920.             fputs( "                    ", f );
  921.             WriteFillIn( f );
  922.             fputs( "\n", f );
  923.         }
  924.         fputs( "                    break;\n", f );
  925.     }
  926.  
  927.     if ( Flag2B & ACTIVEWINDOW_FLAG || Flag2B & ACTIVEWINDOW_F_FLAG ) {
  928.         fputs( "                case IDCMP_ACTIVEWINDOW:\n", f );
  929.         if ( Flag2B & ACTIVEWINDOW_F_FLAG ) {
  930.   fprintf( f, "                    %sActiveWindow%s(", PREFIX_BUF, SUFFIX_BUF );
  931.             Pad( f );
  932.             if ( Variables_FLAG == LOCAL )
  933.                 WriteFillIn( f );
  934.             Pad( f );
  935.             fputs( ");\n", f );
  936.         }
  937.         else {
  938.             fputs( "                    ", f );
  939.             WriteFillIn( f );
  940.             fputs( "\n", f );
  941.         }
  942.         fputs( "                    break;\n", f );
  943.     }
  944.  
  945.     if ( Flag2B & INACTIVEWINDOW_FLAG || Flag2B & INACTIVEWINDOW_F_FLAG ) {
  946.         fputs( "                case IDCMP_INACTIVEWINDOW:\n", f );
  947.         if ( Flag2B & INACTIVEWINDOW_F_FLAG ) {
  948.   fprintf( f, "                    %sInactiveWindow%s(", PREFIX_BUF, SUFFIX_BUF );
  949.             Pad( f );
  950.             if ( Variables_FLAG == LOCAL )
  951.                 WriteFillIn( f );
  952.             Pad( f );
  953.             fputs( ");\n", f );
  954.         }
  955.         else {
  956.             fputs( "                    ", f );
  957.             WriteFillIn( f );
  958.             fputs( "\n", f );
  959.         }
  960.         fputs( "                    break;\n", f );
  961.     }
  962.  
  963.     if ( Flag2B & CHANGEWINDOW_FLAG || Flag2B & CHANGEWINDOW_F_FLAG ) {
  964.         fputs( "                case IDCMP_CHANGEWINDOW:\n", f );
  965.         if ( Flag2B & CHANGEWINDOW_F_FLAG ) {
  966.   fprintf( f, "                    %sChangeWindow%s(", PREFIX_BUF, SUFFIX_BUF );
  967.             Pad( f );
  968.             if ( Variables_FLAG == LOCAL )
  969.                 WriteFillIn( f );
  970.             Pad( f );
  971.             fputs( ");\n", f );
  972.         }
  973.         else {
  974.             fputs( "                    ", f );
  975.             WriteFillIn( f );
  976.             fputs( "\n", f );
  977.         }
  978.         fputs( "                    break;\n", f );
  979.     }
  980.  
  981.     if ( Flag2B & REFRESHWINDOW_FLAG || Flag2B & REFRESHWINDOW_F_FLAG ) {
  982.         fputs( "                case IDCMP_REFRESHWINDOW:\n", f );
  983.         if ( Flag2B & REFRESHWINDOW_F_FLAG ) {
  984.   fprintf( f, "                    %sRefreshWindow%s(", PREFIX_BUF, SUFFIX_BUF );
  985.             Pad( f );
  986.             if ( Variables_FLAG == LOCAL )
  987.                 WriteFillIn( f );
  988.             Pad( f );
  989.             fputs( ");\n", f );
  990.         }
  991.         else {
  992.             fputs( "                    ", f );
  993.             WriteFillIn( f );
  994.             fputs( "\n", f );
  995.         }
  996.         fputs( "                    break;\n", f );
  997.     }
  998.  
  999.     if ( Flag2B & DISKINSERTED_FLAG || Flag2B & DISKINSERTED_F_FLAG ) {
  1000.         fputs( "                case IDCMP_DISKINSERTED:\n", f );
  1001.         if ( Flag2B & DISKINSERTED_F_FLAG ) {
  1002.   fprintf( f, "                    %sDiskInserted%s(", PREFIX_BUF, SUFFIX_BUF );
  1003.             Pad( f );
  1004.             if ( Variables_FLAG == LOCAL )
  1005.                 WriteFillIn( f );
  1006.             Pad( f );
  1007.             fputs( ");\n", f );
  1008.         }
  1009.         else {
  1010.             fputs( "                    ", f );
  1011.             WriteFillIn( f );
  1012.             fputs( "\n", f );
  1013.         }
  1014.         fputs( "                    break;\n", f );
  1015.     }
  1016.  
  1017.     if ( Flag2B & DISKREMOVED_FLAG || Flag2B & DISKREMOVED_F_FLAG ) {
  1018.         fputs( "                case IDCMP_DISKREMOVED:\n", f );
  1019.         if ( Flag2B & DISKREMOVED_F_FLAG ) {
  1020.   fprintf( f, "                    %sDiskRemoved%s(", PREFIX_BUF, SUFFIX_BUF );
  1021.             Pad( f );
  1022.             if ( Variables_FLAG == LOCAL )
  1023.                 WriteFillIn( f );
  1024.             Pad( f );
  1025.             fputs( ");\n", f );
  1026.         }
  1027.         else {
  1028.             fputs( "                    ", f );
  1029.             WriteFillIn( f );
  1030.             fputs( "\n", f );
  1031.         }
  1032.         fputs( "                    break;\n", f );
  1033.     }
  1034.  
  1035.     if ( Flag2B & NEWPREFS_FLAG || Flag2B & NEWPREFS_F_FLAG ) {
  1036.         fputs( "                case IDCMP_NEWPREFS:\n", f );
  1037.         if ( Flag2B & NEWPREFS_F_FLAG ) {
  1038.   fprintf( f, "                    %sNewPrefs%s(", PREFIX_BUF, SUFFIX_BUF );
  1039.             Pad( f );
  1040.             if ( Variables_FLAG == LOCAL )
  1041.                 WriteFillIn( f );
  1042.             Pad( f );
  1043.             fputs( ");\n", f );
  1044.         }
  1045.         else {
  1046.             fputs( "                    ", f );
  1047.             WriteFillIn( f );
  1048.             fputs( "\n", f );
  1049.         }
  1050.         fputs( "                    break;\n", f );
  1051.     }
  1052.  
  1053.     if ( Flag2B & INTUITICKS_FLAG || Flag2B & INTUITICKS_F_FLAG ) {
  1054.         fputs( "                case IDCMP_INTUITICKS:\n", f );
  1055.         if ( Flag2B & INTUITICKS_F_FLAG ) {
  1056.   fprintf( f, "                    %sIntuiTicks%s(", PREFIX_BUF, SUFFIX_BUF );
  1057.             Pad( f );
  1058.             if ( Variables_FLAG == LOCAL )
  1059.                 WriteFillIn( f );
  1060.             Pad( f );
  1061.             fputs( ");\n", f );
  1062.         }
  1063.         else {
  1064.             fputs( "                    ", f );
  1065.             WriteFillIn( f );
  1066.             fputs( "\n", f );
  1067.         }
  1068.         fputs( "                    break;\n", f );
  1069.     }
  1070.  
  1071.     if ( Flag2B & IDCMPUPDATE_FLAG || Flag2B & IDCMPUPDATE_F_FLAG ) {
  1072.         fputs( "                case IDCMP_IDCMPUPDATE:\n", f );
  1073.         if ( Flag2B & IDCMPUPDATE_F_FLAG ) {
  1074.   fprintf( f, "                    %sIDCMPUpdate%s(", PREFIX_BUF, SUFFIX_BUF );
  1075.             Pad( f );
  1076.             if ( Variables_FLAG == LOCAL )
  1077.                 WriteFillIn( f );
  1078.             Pad( f );
  1079.             fputs( ");\n", f );
  1080.         }
  1081.         else {
  1082.             fputs( "                    ", f );
  1083.             WriteFillIn( f );
  1084.             fputs( "\n", f );
  1085.         }
  1086.         fputs( "                    break;\n", f );
  1087.     }
  1088.  
  1089.     if ( Flag2B & LONELYMESSAGE_FLAG || Flag2B & LONELYMESSAGE_F_FLAG ) {
  1090.       fputs( "                case IDCMP_LONELYMESSAGE:\n", f );
  1091.         if ( Flag2B & LONELYMESSAGE_F_FLAG ) {
  1092.   fprintf( f, "                    %sLonelyMessage%s(", PREFIX_BUF, SUFFIX_BUF );
  1093.             Pad( f );
  1094.             if ( Variables_FLAG == LOCAL )
  1095.                 WriteFillIn( f );
  1096.             Pad( f );
  1097.             fputs( ");\n", f );
  1098.         }
  1099.         else {
  1100.             fputs( "                    ", f );
  1101.             WriteFillIn( f );
  1102.             fputs( "\n", f );
  1103.         }
  1104.         fputs( "                    break;\n", f );
  1105.     }
  1106. }
  1107.  
  1108.  
  1109. WriteFSkeletons( FILE *f )
  1110. {
  1111.     fputs( "\n\n", f );
  1112.  
  1113.     if ( Flag2A & MOUSEBUTTONS_F_FLAG ) {
  1114.         if ( Variables_FLAG == LOCAL ) {
  1115.             WriteFillIn( f );
  1116.             Pad( f );
  1117.             fprintf( f, "%sMouseButtons%s(", PREFIX_BUF, SUFFIX_BUF );
  1118.             Pad( f );
  1119.             WriteFillIn( f );
  1120.             Pad( f );
  1121.             fputs( ")\n{\n    ", f );
  1122.             WriteFillIn( f );
  1123.             fputs( "\n}\n\n", f );
  1124.         }
  1125.         else {
  1126.   fprintf( f, "\nvoid %sMouseButtons%s( void ) \n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1127.         }
  1128.     }
  1129.     if ( Flag2A & MOUSEMOVE_F_FLAG ) {
  1130.         if ( Variables_FLAG == LOCAL ) {
  1131.             WriteFillIn( f );
  1132.             Pad( f );
  1133.             fprintf( f, "%sMouseMove%s(", PREFIX_BUF, SUFFIX_BUF );
  1134.             Pad( f );
  1135.             WriteFillIn( f );
  1136.             Pad( f );
  1137.             fputs( ")\n{\n    ", f );
  1138.             WriteFillIn( f );
  1139.             fputs( "\n}\n\n", f );
  1140.         }
  1141.         else {
  1142.   fprintf( f, "\nvoid %sMouseMove%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1143.         }
  1144.     }
  1145.     if ( Flag2A & DELTAMOVE_F_FLAG ) {
  1146.         if ( Variables_FLAG == LOCAL ) {
  1147.             WriteFillIn( f );
  1148.             Pad( f );
  1149.             fprintf( f, "%sDeltaMove%s(", PREFIX_BUF, SUFFIX_BUF );
  1150.             Pad( f );
  1151.             WriteFillIn( f );
  1152.             Pad( f );
  1153.             fputs( ")\n{\n    ", f );
  1154.             WriteFillIn( f );
  1155.             fputs( "\n}\n\n", f );
  1156.         }
  1157.         else {
  1158.   fprintf( f, "\nvoid %sDeltaMove%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1159.         }
  1160.     }
  1161.     if ( Flag2A & GADGETDOWN_F_FLAG ) {
  1162.         if ( Variables_FLAG == LOCAL ) {
  1163.             WriteFillIn( f );
  1164.             Pad( f );
  1165.             fprintf( f, "%sGadgetDown%s(", PREFIX_BUF, SUFFIX_BUF );
  1166.             Pad( f );
  1167.             WriteFillIn( f );
  1168.             Pad( f );
  1169.             fputs( ")\n{\n    ", f );
  1170.             WriteFillIn( f );
  1171.             fputs( "\n}\n\n", f );
  1172.         }
  1173.         else {
  1174.   fprintf( f, "\nvoid %sGadgetDown%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1175.         }
  1176.     }
  1177.     if ( Flag2A & GADGETUP_F_FLAG ) {
  1178.         if ( Variables_FLAG == LOCAL ) {
  1179.             WriteFillIn( f );
  1180.             Pad( f );
  1181.             fprintf( f, "%sGadgetUp%s(", PREFIX_BUF, SUFFIX_BUF );
  1182.             Pad( f );
  1183.             WriteFillIn( f );
  1184.             Pad( f );
  1185.             fputs( ")\n{\n    ", f );
  1186.             WriteFillIn( f );
  1187.             fputs( "\n}\n\n", f );
  1188.         }
  1189.         else {
  1190.   fprintf( f, "\nvoid %sGadgetUp%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1191.         }
  1192.     }
  1193.     if ( Flag2A & CLOSEWINDOW_F_FLAG ) {
  1194.         if ( Variables_FLAG == LOCAL ) {
  1195.             WriteFillIn( f );
  1196.             Pad( f );
  1197.             fprintf( f, "%sCloseWindow%s(", PREFIX_BUF, SUFFIX_BUF );
  1198.             Pad( f );
  1199.             WriteFillIn( f );
  1200.             Pad( f );
  1201.             fputs( ")\n{\n    ", f );
  1202.             WriteFillIn( f );
  1203.             fputs( "\n}\n\n", f );
  1204.         }
  1205.         else {
  1206.   fprintf( f, "\nvoid %sCloseWindow%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1207.         }
  1208.     }
  1209.     if ( Flag2A & MENUPICK_F_FLAG ) {
  1210.         if ( Variables_FLAG == LOCAL ) {
  1211.             WriteFillIn( f );
  1212.             Pad( f );
  1213.             fprintf( f, "%sMenuPick%s(", PREFIX_BUF, SUFFIX_BUF );
  1214.             Pad( f );
  1215.             WriteFillIn( f );
  1216.             Pad( f );
  1217.             fputs( ")\n{\n    ", f );
  1218.             WriteFillIn( f );
  1219.             fputs( "\n}\n\n", f );
  1220.         }
  1221.         else {
  1222.   fprintf( f, "\nvoid %sMenuPick%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1223.         }
  1224.     }
  1225.     if ( Flag2A & MENUVERIFY_F_FLAG ) {
  1226.         if ( Variables_FLAG == LOCAL ) {
  1227.             WriteFillIn( f );
  1228.             Pad( f );
  1229.             fprintf( f, "%sMenuVerify%s(", PREFIX_BUF, SUFFIX_BUF );
  1230.             Pad( f );
  1231.             WriteFillIn( f );
  1232.             Pad( f );
  1233.             fputs( ")\n{\n    ", f );
  1234.             WriteFillIn( f );
  1235.             fputs( "\n}\n\n", f );
  1236.         }
  1237.         else {
  1238.   fprintf( f, "\nvoid %sMenuVerify%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1239.         }
  1240.     }
  1241.     if ( Flag2A & MENUHELP_F_FLAG ) {
  1242.         if ( Variables_FLAG == LOCAL ) {
  1243.             WriteFillIn( f );
  1244.             Pad( f );
  1245.             fprintf( f, "%sMenuHelp%s(", PREFIX_BUF, SUFFIX_BUF );
  1246.             Pad( f );
  1247.             WriteFillIn( f );
  1248.             Pad( f );
  1249.             fputs( ")\n{\n    ", f );
  1250.             WriteFillIn( f );
  1251.             fputs( "\n}\n\n", f );
  1252.         }
  1253.         else {
  1254.   fprintf( f, "\nvoid %sMenuHelp%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1255.         }
  1256.     }
  1257.     if ( Flag2A & RAWKEY_F_FLAG ) {
  1258.         if ( Variables_FLAG == LOCAL ) {
  1259.             WriteFillIn( f );
  1260.             Pad( f );
  1261.             fprintf( f, "%sRawKey%s(", PREFIX_BUF, SUFFIX_BUF );
  1262.             Pad( f );
  1263.             WriteFillIn( f );
  1264.             Pad( f );
  1265.             fputs( ")\n{\n    ", f );
  1266.             WriteFillIn( f );
  1267.             fputs( "\n}\n\n", f );
  1268.         }
  1269.         else {
  1270.   fprintf( f, "\nvoid %sRawKey%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1271.         }
  1272.     }
  1273.     if ( Flag2A & VANILLAKEY_F_FLAG ) {
  1274.         if ( Variables_FLAG == LOCAL ) {
  1275.             WriteFillIn( f );
  1276.             Pad( f );
  1277.             fprintf( f, "%sVanillaKey%s(", PREFIX_BUF, SUFFIX_BUF );
  1278.             Pad( f );
  1279.             WriteFillIn( f );
  1280.             Pad( f );
  1281.             fputs( ")\n{\n    ", f );
  1282.             WriteFillIn( f );
  1283.             fputs( "\n}\n\n", f );
  1284.         }
  1285.         else {
  1286.   fprintf( f, "\nvoid %sVanillaKey%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1287.         }
  1288.     }
  1289.     if ( Flag2A & REQSET_F_FLAG ) {
  1290.         if ( Variables_FLAG == LOCAL ) {
  1291.             WriteFillIn( f );
  1292.             Pad( f );
  1293.             fprintf( f, "%sReqSet%s(", PREFIX_BUF, SUFFIX_BUF );
  1294.             Pad( f );
  1295.             WriteFillIn( f );
  1296.             Pad( f );
  1297.             fputs( ")\n{\n    ", f );
  1298.             WriteFillIn( f );
  1299.             fputs( "\n}\n\n", f );
  1300.         }
  1301.         else {
  1302.   fprintf( f, "\nvoid %sReqSet%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1303.         }
  1304.     }
  1305.     if ( Flag2A & REQCLEAR_F_FLAG ) {
  1306.         if ( Variables_FLAG == LOCAL ) {
  1307.             WriteFillIn( f );
  1308.             Pad( f );
  1309.             fprintf( f, "%sReqClear%s(", PREFIX_BUF, SUFFIX_BUF );
  1310.             Pad( f );
  1311.             WriteFillIn( f );
  1312.             Pad( f );
  1313.             fputs( ")\n{\n    ", f );
  1314.             WriteFillIn( f );
  1315.             fputs( "\n}\n\n", f );
  1316.         }
  1317.         else {
  1318.   fprintf( f, "\nvoid %sReqClear%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1319.         }
  1320.     }
  1321.     if ( Flag2A & REQVERIFY_F_FLAG ) {
  1322.         if ( Variables_FLAG == LOCAL ) {
  1323.             WriteFillIn( f );
  1324.             Pad( f );
  1325.             fprintf( f, "%sReqVerify%s(", PREFIX_BUF, SUFFIX_BUF );
  1326.             Pad( f );
  1327.             WriteFillIn( f );
  1328.             Pad( f );
  1329.             fputs( ")\n{\n    ", f );
  1330.             WriteFillIn( f );
  1331.             fputs( "\n}\n\n", f );
  1332.         }
  1333.         else {
  1334.   fprintf( f, "\nvoid %sReqVerify%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1335.         }
  1336.     }
  1337.     if ( Flag2B & NEWSIZE_F_FLAG ) {
  1338.         if ( Variables_FLAG == LOCAL ) {
  1339.             WriteFillIn( f );
  1340.             Pad( f );
  1341.             fprintf( f, "%sNewSize%s(", PREFIX_BUF, SUFFIX_BUF );
  1342.             Pad( f );
  1343.             WriteFillIn( f );
  1344.             Pad( f );
  1345.             fputs( ")\n{\n    ", f );
  1346.             WriteFillIn( f );
  1347.             fputs( "\n}\n\n", f );
  1348.         }
  1349.         else {
  1350.   fprintf( f, "\nvoid %sNewSize%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1351.         }
  1352.     }
  1353.     if ( Flag2B & SIZEVERIFY_F_FLAG ) {
  1354.         if ( Variables_FLAG == LOCAL ) {
  1355.             WriteFillIn( f );
  1356.             Pad( f );
  1357.             fprintf( f, "%sSizeVerify%s(", PREFIX_BUF, SUFFIX_BUF );
  1358.             Pad( f );
  1359.             WriteFillIn( f );
  1360.             Pad( f );
  1361.             fputs( ")\n{\n    ", f );
  1362.             WriteFillIn( f );
  1363.             fputs( "\n}\n\n", f );
  1364.         }
  1365.         else {
  1366.   fprintf( f, "\nvoid %sSizeVerify%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1367.         }
  1368.     }
  1369.     if ( Flag2B & ACTIVEWINDOW_F_FLAG ) {
  1370.         if ( Variables_FLAG == LOCAL ) {
  1371.             WriteFillIn( f );
  1372.             Pad( f );
  1373.             fprintf( f, "%sActiveWindow%s(", PREFIX_BUF, SUFFIX_BUF );
  1374.             Pad( f );
  1375.             WriteFillIn( f );
  1376.             Pad( f );
  1377.             fputs( ")\n{\n    ", f );
  1378.             WriteFillIn( f );
  1379.             fputs( "\n}\n\n", f );
  1380.         }
  1381.         else {
  1382.   fprintf( f, "\nvoid %sActiveWindow%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1383.         }
  1384.     }
  1385.     if ( Flag2B & INACTIVEWINDOW_F_FLAG ) {
  1386.         if ( Variables_FLAG == LOCAL ) {
  1387.             WriteFillIn( f );
  1388.             Pad( f );
  1389.             fprintf( f, "%sInactiveWindow%s(", PREFIX_BUF, SUFFIX_BUF );
  1390.             Pad( f );
  1391.             WriteFillIn( f );
  1392.             Pad( f );
  1393.             fputs( ")\n{\n    ", f );
  1394.             WriteFillIn( f );
  1395.             fputs( "\n}\n\n", f );
  1396.         }
  1397.         else {
  1398.   fprintf( f, "\nvoid %sInactiveWindow%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1399.         }
  1400.     }
  1401.     if ( Flag2B & CHANGEWINDOW_F_FLAG ) {
  1402.         if ( Variables_FLAG == LOCAL ) {
  1403.             WriteFillIn( f );
  1404.             Pad( f );
  1405.             fprintf( f, "%sChangeWindow%s(", PREFIX_BUF, SUFFIX_BUF );
  1406.             Pad( f );
  1407.             WriteFillIn( f );
  1408.             Pad( f );
  1409.             fputs( ")\n{\n    ", f );
  1410.             WriteFillIn( f );
  1411.             fputs( "\n}\n\n", f );
  1412.         }
  1413.         else {
  1414.   fprintf( f, "\nvoid %sChangeWindow%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1415.         }
  1416.     }
  1417.     if ( Flag2B & REFRESHWINDOW_F_FLAG ) {
  1418.         if ( Variables_FLAG == LOCAL ) {
  1419.             WriteFillIn( f );
  1420.             Pad( f );
  1421.             fprintf( f, "%sRefreshWindow%s(", PREFIX_BUF, SUFFIX_BUF );
  1422.             Pad( f );
  1423.             WriteFillIn( f );
  1424.             Pad( f );
  1425.             fputs( ")\n{\n    ", f );
  1426.             WriteFillIn( f );
  1427.             fputs( "\n}\n\n", f );
  1428.         }
  1429.         else {
  1430.   fprintf( f, "\nvoid %sRefreshWindow%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1431.         }
  1432.     }
  1433.     if ( Flag2B & DISKINSERTED_F_FLAG ) {
  1434.         if ( Variables_FLAG == LOCAL ) {
  1435.             WriteFillIn( f );
  1436.             Pad( f );
  1437.             fprintf( f, "%sDiskInserted%s(", PREFIX_BUF, SUFFIX_BUF );
  1438.             Pad( f );
  1439.             WriteFillIn( f );
  1440.             Pad( f );
  1441.             fputs( ")\n{\n    ", f );
  1442.             WriteFillIn( f );
  1443.             fputs( "\n}\n\n", f );
  1444.         }
  1445.         else {
  1446.   fprintf( f, "\nvoid %sDiskInserted%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1447.         }
  1448.     }
  1449.     if ( Flag2B & DISKREMOVED_F_FLAG ) {
  1450.         if ( Variables_FLAG == LOCAL ) {
  1451.             WriteFillIn( f );
  1452.             Pad( f );
  1453.             fprintf( f, "%sDiskRemoved%s(", PREFIX_BUF, SUFFIX_BUF );
  1454.             Pad( f );
  1455.             WriteFillIn( f );
  1456.             Pad( f );
  1457.             fputs( ")\n{\n    ", f );
  1458.             WriteFillIn( f );
  1459.             fputs( "\n}\n\n", f );
  1460.         }
  1461.         else {
  1462.   fprintf( f, "\nvoid %sDiskRemoved%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1463.         }
  1464.     }
  1465.     if ( Flag2B & NEWPREFS_F_FLAG ) {
  1466.         if ( Variables_FLAG == LOCAL ) {
  1467.             WriteFillIn( f );
  1468.             Pad( f );
  1469.             fprintf( f, "%sNewPrefs%s(", PREFIX_BUF, SUFFIX_BUF );
  1470.             Pad( f );
  1471.             WriteFillIn( f );
  1472.             Pad( f );
  1473.             fputs( ")\n{\n    ", f );
  1474.             WriteFillIn( f );
  1475.             fputs( "\n}\n\n", f );
  1476.         }
  1477.         else {
  1478.   fprintf( f, "\nvoid %sNewPrefs%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1479.         }
  1480.     }
  1481.     if ( Flag2B & INTUITICKS_F_FLAG ) {
  1482.         if ( Variables_FLAG == LOCAL ) {
  1483.             WriteFillIn( f );
  1484.             Pad( f );
  1485.             fprintf( f, "%sIntuiTicks%s(", PREFIX_BUF, SUFFIX_BUF );
  1486.             Pad( f );
  1487.             WriteFillIn( f );
  1488.             Pad( f );
  1489.             fputs( ")\n{\n    ", f );
  1490.             WriteFillIn( f );
  1491.             fputs( "\n}\n\n", f );
  1492.         }
  1493.         else {
  1494.   fprintf( f, "\nvoid %sIntuiTicks%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1495.         }
  1496.     }
  1497.     if ( Flag2B & IDCMPUPDATE_F_FLAG ) {
  1498.         if ( Variables_FLAG == LOCAL ) {
  1499.             WriteFillIn( f );
  1500.             Pad( f );
  1501.             fprintf( f, "%sIDCMPUpdate%s(", PREFIX_BUF, SUFFIX_BUF );
  1502.             Pad( f );
  1503.             WriteFillIn( f );
  1504.             Pad( f );
  1505.             fputs( ")\n{\n    ", f );
  1506.             WriteFillIn( f );
  1507.             fputs( "\n}\n\n", f );
  1508.         }
  1509.         else {
  1510.   fprintf( f, "\nvoid %sIDCMPUpdate%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1511.         }
  1512.     }
  1513.     if ( Flag2B & LONELYMESSAGE_F_FLAG ) {
  1514.         if ( Variables_FLAG == LOCAL ) {
  1515.             WriteFillIn( f );
  1516.             Pad( f );
  1517.             fprintf( f, "%sLonelyMessage%s(", PREFIX_BUF, SUFFIX_BUF );
  1518.             Pad( f );
  1519.             WriteFillIn( f );
  1520.             Pad( f );
  1521.             fputs( ")\n{\n    ", f );
  1522.             WriteFillIn( f );
  1523.             fputs( "\n}\n\n", f );
  1524.         }
  1525.         else {
  1526.  
  1527.   fprintf( f, "\nvoid %sLonelyMessage%s( void )\n{\n\n}\n\n", PREFIX_BUF, SUFFIX_BUF );
  1528.         }
  1529.     }
  1530. }
  1531.  
  1532.  
  1533. int WriteFillIn( FILE *f )
  1534. {
  1535.     switch ( FillIns_FLAG ) {
  1536.         case 0:
  1537.             return( 0 );
  1538.         case 1:
  1539.             fputs( "@@@@@@@@@@", f );
  1540.             break;
  1541.         case 2:
  1542.             fputs( "/* @@ */", f );
  1543.             break;
  1544.         case 3:
  1545.             fputs( "@@", f );
  1546.             break;
  1547.     }
  1548. }
  1549.  
  1550.  
  1551. int Pad( *f )
  1552. {
  1553.     if ( FillIns_FLAG != FILLS_NONE && Variables_FLAG == LOCAL ) {
  1554.         fputs( " ", f );
  1555.     }
  1556. }